package com.example.kotlin01

//1.无参数，无返回值的函数 转换成lambda表达式
//源代码
//fun test(){
//    println("无参数的函数")
//}
// lambda代码
val test = { println("无参数") }


//2.带参数和返回值的函数，转换成lambda表达式
//源代码
//有参数a和b
//返回值是Int
//fun sum(a:Int,b:Int):Int{
//    return a+b;
//}
// lambda代码1
//val sum = {a:Int,b:Int->a+b}
// lambda代码2
//sum表达式名称
//（Int,In）参数类型
//Int返回值类型
//{}里的内容分别为参数和函数体
val sum: (Int, Int) -> Int = { a, b -> a + b }


val bool: (Int) -> Boolean = { it > 5 }


fun test(num1: Int, bool: (Int) -> Boolean): Int {
    return if (bool(num1)) {
        num1
    } else 0
}


// lambda
fun test(a: Int, b: (num1: Int, num2: Int) -> Int): Int {
    return a + b(3, 5)
}


//参数分别为a和test06 lambda表达式
//lambda表达式作为函数的参数 大概可以理解为：
// 参数是声明的函数名称，入参，返回值，调用的时候，传入函数体。这样就形成了一个完整的函数
//
fun test06(a: Int, b: (num1: Int, num2: Int) -> Int): Int {
    return a + b(a, a)
}


//有参数，有返回值普通函数函数
fun test03(a: Int, b: Int): Int {
    return a + b
}

//lambda表达式写法1(需要编写返回值类型)
val test04: (Int, Int) -> Int = { a, b -> a + b }

////lambda表达式写法2（不需要编写返回值类型）
val test05 = { a: Int, b: Int ->
    a + b
}


//无参数，无返回值普通函数函数
fun test01() {
    println("无参数，无返回值函数")
}

//无参数，无返回值普通函数函数的lambda表达式
val test02 = { println("无参数，无返回值函数") }


fun main() {
    sum(1,2)
    testRun2()
}

fun testRun2() {
    val value = "weishixiong";
    repeat(5,{
        println(value)

    })
}


fun testRun() {
    val value = run {
        val str = "Java"
        str
    }
}


val test12 = { a: Int -> println(a) }


val map =
    mapOf("key01" to "value01", "key02" to "value02", "key03" to "value03", "key04" to "value04")

val test07: (Int) -> Int = { it }


fun test8() {
    fun test() {   // 正确，因为Kotlin中可以函数嵌套函数

    }
}






